L'intento di questo corso è di dare le nozioni di base per scrivere semplici programmi per Windows utilizzando il linguaggio di programmazione più diffuso ai nostri giorni. I prerequisiti essenziali per poter affrontare "con tranquillità" le lezioni sono: concetti di programmazione (non necessariamente sotto Windows) e una certa familiarità con l'uso di Windows. La programmazione ad Oggetti (OOP) Dando già per scontato cosa significa "programmare" un computer, cerchiamo di spiegare cosa significa "programmare ad oggetti". Conoscere questo tipo di programmazione è fondamentale per poter accedere ed utilizzare le librerie fornite dal sistema operativo Windows ed è importante per creare programmi facilmente leggibili e riutilizzabili. In un'architettura di tipo object-oriented ("ad oggetti") l'elemento cardine attorno al quale si basa il progetto è l'oggetto. -------------------------------------------------------------------------------------------------------------- Nella fase di progettazione del software, il progettista ha necessità di astrarre dai dettagli e deve poter disegnare il software da un punto di vista concettuale. Ecco che l'oggetto, incapsulando (e nascondendo) sia dati che codice, è uno strumento validissimo per questo scopo. Facciamo un esempio: supponiamo che la progettazione del nostro software preveda la suddivisione dei programmi in più reparti. Il reparto A ha il compito di creare le librerie per la gestione del personale, i programmatori del reparto A avranno creato un oggetto "impiegato" che avrà come proprietà il "nome", il "cognome" e così via e delle funzioni (metodi) tipiche di questo oggetto come "CalcolaSalario" ecc. Se il reparto B avrà bisogno di utilizzare l'oggetto impiegato non dovrà entrare nel merito di come si calcola un salario, ma potrà usare direttamente il metodo "CalcolaSalario". La programmazione orientata agli oggetti è nata proprio per produrre modelli della realtà. ------------------------------------------------------------------------------------------------------------- I punti cardine della programmazione ad oggetti sono: l’incapsulamento, è uno strumento che permette di costruire una classe e di "racchiuderla in una scatola nera" di cui non è possibile vedere il contenuto facendo in modo però che tale contenuto possa essere utilizzato per mezzo di procedure facenti parte della classe stessa. l'ereditarietà è la capacità di un oggetto padre di tramandare la propria natura ad altri oggetti. Le classi derivate sono anche chiamate "sottoclassi'' Il polimorfismo, indica la capacità di un oggetto di assumere forme diverse. Un oggetto polimorfo, è un oggetto appartenente ad una classe che ha oggetti discendenti, di cui può assumere tutte le caratteristiche. ------------------------------------------------------------------------------------------------------------ programmazione guidata dagli Eventi La programmazione in ambiente Windows è definita Event-Driven (cioè guidata dagli eventi), ciò significa che le istruzioni del programma creato vengono eseguite non in modo sequenziale una dopo l'altra (come la programmazione "vecchia maniera"), ma in seguito al verificarsi di determinati eventi (selezione di un menù, pressione di un bottone, apertura di una finestra ecc.). Cos’è Visual Basic ? Visual Basic è uno strumento che permette di sviluppare applicazioni Windows grafiche (Graphic User Interface - GUI) in modo facile, rapido ed intuitivo. Visual Basic è di tipo event-driven (infatti è governato da un processore di eventi) ed è anche (nella versione 6 ancora non completamente) un linguaggio di tipo object oriented. --------------------------------------------------------------------------------------------------------- po’ di storia... Il linguaggio BASIC fu sviluppato nel 1960 al Dartmouth College e rappresenta il seguente acronimo: B(eginner's), A(ll-Purpose), S(ymbolic), I(nstruction), C(ode). Visual Basic 1.0 fu introdotto nel 1991: in versione per DOS e per Windows (3.x). Visual Basic 3.0 fu rilasciato nel 1993. Visual Basic 4.0 alla fine 1995 (con la prima versione a 32 bit e l'ultima a 16 bit). Visual Basic 5.0 alla fine del 1996 Visual Basic 6.0 alla fine del 1998 Infine, cerchiamo di capire i termini più utilizzati in VB Controllo: un elemento utilizzabile dal linguaggio che serve per visualizzare output, immettere input o permettere altre utilità; bottoni, combobox, cornici sono esempi di controlli utilizzabili; --------------------------------------------------------------------------------------------------------------- Evento: qualsiasi azione che l’applicazione può riconoscere ed intercettare Focus: un controllo ha il focus quando è pronto per ricevere il prossimo evento Funzione: procedura (gruppo di istruzioni) che restituisce un valore Metodo: procedura associata ad un oggetto Modulo: file singolo contente solo codice visual basic Oggetto: elemento in un’applicazione per il quale si possono definire proprietà o scrivere codice Proprietà: attributo di un oggetto Progetto: applicazione in fase di sviluppo composta da molti file Per questa lezione è tutto. Ci "vediamo" alla prossima, dove inizieremo a prendere familiarità con l'ambiente di lavoro di Visual Basic. ----------------------------------------------------------------------------------------------------------Eccoci alla seconda lezione del corso di VB. Dopo aver appreso i primi concetti teorici, passiamo alla conoscenza dell'ambiente, della metodologia di lavoro e delle varie parti che compongono il progetto. Come si sviluppa un progetto La prima fase di un progetto VB (naturalmente dopo aver fatto un'accurata analisi dei risultati che si vogliono ottenere) è la creazione delle maschere, alle quali andranno poi aggiunte le caselle per l'inserimento del testo, i bottoni ecc. (in generale inserimento dei "controlli"). Successivamente occorrerà aggiungere il codice per "insegnare" ad ogni pulsante cosa deve fare, per stabilire cosa deve "succedere" quando scatta un determinato evento e così via. Finita questa fase si procederà alla creazione dell'eseguibile e poi del pacchetto di installazione. ----------------------------------------------------------------------------------------------------------- Come è fatto un progetto Un classico progetto Visual Basic è costituito da: Forms (file .FRM): finestre utilizzate per creare l’interfaccia utente Controlli: oggetti grafici inseriti sulle finestre che permettono l’iterazione con l’utente (caselle di testo, etichette ecc.) Proprietà: ogni caratteristica di una form o di un controllo e specificata da una proprietà, esempi di proprietà sono il nome, le dimensioni, il colore, la posizione… Metodi: procedure che fanno parte di un oggetto e possono essere invocate per eseguire una determinata azione. Procedure evento: parte di codice (istruzioni) che vengono invocate automaticamente quando scatta un determinato evento. Procedure generali: codice non legato a nessun oggetto, deve essere richiamato da un’altra istruzione. Moduli (file .BAS) - collezione di procedure generali, variabili e costanti usate nell’applicazione Classi (file .CLS) - parte di codice che racchiude la definizione di oggetti, di suo metodi e proprietà. ---------------------------------------------------------------------------------------------------------------- Operatività Nell'ambiente di lavoro di Visual Basic si opera in 3 modi: Design (progettazione): quando si sta costruendo l’applicazione Run (esecuzione): quando si sta eseguendo l’applicazione (dall'ambiente di lavoro, non da eseguibile già creato!) Break: in fase di debug (controllo passo passo) dell’applicazione ossia quando si vogliono testare errori e comportamento di istruzioni. L’ambiente Proviamo ad avviare Visual Basic per la prima volta, ossia dal menù "Start" di Windows cerchiamo la voce "Microsoft Visual Basic 6.0" e lanciamola. La prima cosa che ci viene chiesta è di scegliere se aprire un progetto già esistente o di crearne uno nuovo. Ma se volessimo crearlo nuovo che tipo di progetto dobbiamo scegliere? Per il momento scegliamo "EXE Standard", nelle future lezioni ci soffermeremo sugli altri. ------------------------------------------------------------------------------------------------------------ A questo punto ci troviamo nell'ambiente di lavoro vero e proprio; appaiono 6 finestre: la finestra principale (quella contenente tutte le altre, i menù, la toolbar ecc.) la finestra della form (quella contenente la prima maschera) la casella degli strumenti (che permette di selezionare controlli ed aggiungerli alla form) la finestra delle proprietà (nella quale si possono impostare le proprietà della form e degli elementi contenuti in essa) la finestra del progetto (dove sono elencati tutti i componenti del progetto). In automatico è già stata creata una prima finestra vuota denominata "Form1" che in seguito proveremo a personalizzare. Ma dov'è la finestra del codice? Ossia, dove andiamo ad inserire le istruzioni in BASIC? ---------------------------------------------------------------------------------------------------------------- Facendo doppio click in un'area qualsiasi della finestra o premendo l’apposito pulsante "Visualizza Codice" nella finestra del progetto si aprirà un'altra finestra, ossia l'editor. L’editor del codice Vedremo che scrivere codice Visual Basic è facile: vengono proposti in automatico proprietà e metodi di oggetti (AUTOLIST), viene visualizzata la sintassi di procedure e funzioni (AUTOQUICK), le parole riservate al linguaggio vengono automaticamente visualizzate in blu e i nomi di variabili già dichiarate vengono visualizzate come scritte nella dichiarazione (ad es. se dichiariamo una variabile con la prima lettera maiuscola Pippo e poi la riscriviamo più sotto come pippo, ci verrà convertita automaticamente in Pippo). Ed anche per questa lezione è tutto! Alla prossima, dove inizieremo a costruire la nostra prima finestra. ---------------------------------------------------------------------------------------------------------------- Oggi finalmente iniziamo a creare il primo piccolo progetto Visual Basic. Caricamento di un programma Nella scorsa lezione avevamo imparato ad aprire Visual Basic, se nel frattempo lo avete chiuso :) vi ricordo che lo lanciate dalla voce "Microsoft Visual Basic 6.0" menù "Start" di Windows. Partiamo ancora da un progetto nuovo di tipo “Exe Standard”, in realtà il progetto creato non è vuoto ma contiene già una finestra denominata FORM1 (vedremo successivamente come cambiare nome a quest’ultima e a tutto il progetto). Se lo eseguiamo (ciccando sul menù “Esegui” – “Avvia” o sulla freccia del “play” o semplicemente premendo F5) verrà lanciata la nostra prima applicazione (in RUN mode, cioè interpretata e non lanciata da un eseguibile vero e proprio), la quale non contiene nessuna scritta o pulsante, ma solo la barra del titolo della FORM1 e i pulsanti standard di chiusura e riduzione della finestra.. ma FUNZIONA!!! ---------------------------------------------------------------------------------------------------------------- Oggetti e Proprietà Come accennato nelle lezione precedente, la programmazione Visual Basic si appoggia su degli oggetti. Impareremo più approfonditamente, in questa lezione, a creare la parte grafica di un’applicazione aggiungendo controlli ovvero pulsanti, scritte, liste ecc.(che non sono altro che oggetti) ad una finestra ed impostandone gli attributi (proprietà) in fase di progettazione. La Casella degli Strumenti La casella degli strumenti, o toolbox, è quella finestra piena di “disegnini”che si trova nella parte sinistra del video. Essa, in un progetto nuovo come il nostro, contiene i controlli più comuni contenuti in VB, ma è possibile personalizzarla inserendo altri controlli forniti con VB oppure anche con controlli di terze parti. ---------------------------------------------------------------------------------------------------------------- Inserimento di controlli su una FORM L’interfaccia utente si disegna dalla finestra delle form, qui possiamo aggiungere gli oggetti che ci servono. Esistono vari modi per mettere i controlli sulle form: - doppio-click sul controllo desiderato che si trova nella casella degli strumenti; in tal modo il controllo viene creato con una dimensione di default - click nella casella degli strumenti sul controllo desiderato, e creazione di esso ciccando sulla form e poi trascinandolo con il mouse (in questo modo si possono dare le dimensioni e la posizione volute) - copiando da un controllo esistente. Modifica e rimozione dei controlli Per spostare un controllo già disegnato su una form selezionarlo con click e trascinarlo. Per ridimensionare un controllo, selezionarlo con click, muovere il mouse fino a quando viene visualizzato il puntatore per il resize (quello a doppia freccia). Per cancellare un controllo, selezionarlo con click, e digitare il tasto Canc (oppure dal menù che appare cilccando il tasto destro del mouse scegliere Elimina) ----------------------------------------------------------------------------------------------------------------- Impostare le proprietà in fase di progettazione Ogni form ed ogni controllo ha delle proprietà già assegnate di default quando viene creato. La finestra che elenca le proprietà di un oggetto (controllo, finestra o addirittura anche del progetto intero) si trova nella parte destra dello schermo: tale finestra ci permette di modificare le proprietà in fase di progettazione, per modificarle durante l’esecuzione del programma occorrerà attendere ancora qualche lezione. Le proprietà sono visualizzate in ordine alfabetico o raggruppate per categoria. Ci sono due modi per visualizzare le proprietà di un oggetto. Il primo è di cliccare sull’oggetto: nella finestra delle proprietà saranno elencate quelle dell’oggetto selezionato. Il secondo modo è di scegliere l’oggetto desiderato dalla lista che ci è proposta in alto nella finestra delle proprietà. ----------------------------------------------------------------------------------------------------------------- Un Piccolo Esercizio Proviamo a modificare il testo visualizzato nella barra del titolo della nostra finestra ed il nome della finestra: clicchiamo in un punto vuoto (dove non ci sono controlli) della finestra, dovremmo vedere nella finestra delle Proprietà il titolo “Proprietà – Form1” spostiamoci sulla proprietà Name: sostituiamo al testo “Form1” il testo “FrmCorsoVb”, abbiamo così cambiato il nome del nostro oggetto finestra e ci siamo attenuti ad una convenzione consigliata ed adottata dai programmatori VB che suggerisce di mettere un suffisso identificativo del tipo di oggetto. spostiamoci sulla proprietà Caption: sostituiamo al testo “Form1” il testo “Titolo della finestra” e magicamente vedremo modificare il titolo. ---------------------------------------------------------------------------------------------------------------- In questa lezione vedremo in dettaglio le principali proprietà della finestra e di alcuni controlli. Proprietà comuni a molti controlli Abbiamo visto la volta scorsa come fare ad impostare le proprietà in fase di progettazione; esse possono aver valori numerici, booleani (VERO o FALSO), testo, oppure valori numerici tabellati, come ad esempio il “border style” della finestra ha come valore possibili: 0 –nessun bordo, 1 – bordo fisso singolo, 2 – ridimensionabile ecc.. L’ambiente di VB per facilitarci il lavoro ci propone già i possibili valori decodificati in una combo-box (elenco che si espande cliccando sulla freccina a destra), quindi non è importante ricordarsi tutti i possibili valori. Ecco le proprietà che ritroviamo in quasi tutti i tipi di controlli: BackColor: colore di sfondo BorderStyle: tipo di bordo (fisso, dimensionabile..) ----------------------------------------------------------------------------------------------------------------- Enabled: imposta un valore che determina se l’oggetto è abilitato o meno (cioè in grado di rispondere agli eventi generati) FillColor: restituisce o imposta il colore di riempimento dell’oggetto Height: altezza dell’oggetto in twips Left: distanza (in twips) dal margine di sinistra rispetto al suo container Top: distanza (in twips) dall’angolo in alto a sinistra rispetto al suo container ToolTipText: etichetta di testo che viene visualizzata quando il mouse si posiziona per qualche secondo sul controllo Visible: se impostata a false l’oggetto non è visibile Width: larghezza dell’oggetto in twips TabIndex: indica l’ordine di tabulazione dell’oggetto all’interno della form (cioè l’ordine con cui si passa da un controllo all’altro digitando il tasto TAB) TabStop: indica se è possibile utilizzare il tasto TAB per spostare lo stato attivo su un oggetto ---------------------------------------------------------------------------------------------------------------- Cos’è un twip? Il twip è l’unità di misura utilizzata per specificare dimensioni e posizioni delle form e dei controlli; è screen-independent, cioè non dipende dalla dimensione del video. Un twip è un’unità di lunghezza equivalente a 1/1440 di un pollice o 1/567 di un centimetro Le principali Proprietà della Form Autoredraw: determina se il form deve automaticamente ridisegnare se stesso quando necessario, solitamente, in altri linguaggi più a basso livello quali il VC++, se disegniamo qualcosa sulla finestra (non i controlli inseriti in fase di progettazione, ma solo testi e disegni che possiamo dipingere in fase di esecuzione), dobbiamo anche farci carico del ridisegnamento della stessa quando viene spostata o ridimensionata; impostando questa proprietà a TRUE, il programmatore VB non deve preoccuparsi di questo aspetto ------------------------------------------------------------------------------------------------------------- BorderStyle: imposta il tipo di bordo (fisso, dimensionabile..) Caption: testo visualizzato nella barra del titolo (parte blu in alto della finestra) Font: font utilizzato se si scrive sulla finestra (utilizzando il metodo Print spiegato dopo) ForeColor: restituisce o imposta il colore utilizzato per la visualizzazione di testo e grafica di sfondo nella finestra Icon: immagine visualizzata in alto a sinistra sulla barra del titolo MaxButton: determina se nel form è disponibile il pulsante di ingrandimento MDIChild: Determina se i form è visualizzato come un figlio di una finestra che lo contiene MinButton: determina se nella finestra è disponibile il pulsante di riduzione a icona WindowState: stato della finestra (ingrandita, minimizzata..) ---------------------------------------------------------------------------------------------------------------- Proprietà particolari del controllo LABEL Ricordiamo innanzi tutto che il controllo label è quel controllo che permette di visualizzare delle etichette di testo ed è rappresentato da un quadratino con una A maiuscola. Solitamente lo si usa a sinistra, per specificare il contenuto di un campo di immissione testo (textbox, combobox..) Le sue proprietà più utilizzate, oltre a quelle viste sopra, sono: Alignment: tipo di allineamento del testo visualizzato nell’etichetta (destra, centro, sinistra) Autosize: abilita il ridimensionamento automatico a seconda dell’ampiezza del testo contenuto ---------------------------------------------------------------------------------------------------------------- Proprietà particolari del controllo Command Button Il Command Button non è altro che il classico pulsante da cliccare per confermare, annullare o eseguire un’azione. Nella casella degli strumenti è rappresentato come un rettangolino in rilievo; le sue proprietà più utilizzate, oltre a quelle viste sopra, sono: Cancel: abilita l’esecuzione del codice associato al pulsante premendo il tasto ESC Default: determina il pulsante predefinito (cioè quello che viene eseguito dando INVIO) Style: abilita il formato standard o grafico di un pulsante; per poter inserire un’immagine su un pulsante è obbligatorio impostare questo valore su “graphical” Arrivederci alla prossima dove vedremo le proprietà di altri controlli e forse, finalmente, anche qualche istruzione.. :-) ---------------------------------------------------------------------------------------------------------------- Nella lezione di oggi continuiamo con altre proprietà ed inizieremo a capire gli eventi e le istruzioni Proprietà particolari del controllo Text Box Ricordiamo innanzi tutto che il controllo TextBox (o casella di testo) è quel controllo che permette all’utente di inserire dei dati e, nella casella degli strumenti, è rappresentato come un quadratino contenente le lettere “ab”. Le sue proprietà principali, oltre a quelle comuni agli altri controlli sono: Text: proprietà che restituisce od imposta il testo contenuto nel controllo Selected Text: proprietà che restituisce od imposta il testo selezionato in blu SelStart: restituisce o imposta l’inizio di un intervallo di selezione SelLen: restituisce o imposta la lunghezza di un intervallo di selezione ScrollBars: valore logico che permette di abilitare o meno le barre di scorrimento orizzontali o verticali PasswordChar: determina se vengono nascosti i caratteri digitati dall’utente (con ad es.*) ---------------------------------------------------------------------------------------------------------------- Altre Proprietà importanti della form Icon: specifica l’icona visualizzata sulla barra del titolo o quando è ridotta MousePointer: imposta il puntatore del mouse (anche in fase di esecuzione, molto comoda per tempi di attesa: lo vedremo più avanti) Moveable: definisce se è possibile muovere la finestra Picture: imposta un’immagine sulla finestra Dopo queste prime lezioni siamo in grado di progettare la parte grafica di un progetto e di impostare le proprietà iniziali, ma non siamo ancora in grado di rendere l’applicazione dinamica, cioè ancora non sappiamo inserire il codice che gestisca i dati inseriti dall’utente, che permetta di aprire altre finestre, ecc. Nel frattempo, per esercitarvi e per verificare ciò che abbiamo appreso fino ad ora, vi propongo un semplice esercizio. ---------------------------------------------------------------------------------------------------------------- Esercizio Creare un progetto nuovo chiamandolo PrjMioPrimoProgetto. Tale progetto deve contenere una finestra denominata FrmMain con le seguenti nuove caratteristiche: - larghezza 5300 twips - altezza 4300 twips - un’icona - non potrà essere ridimensionata e ridotta a icona - un pulsante CmdScrivi recante la dicitura “Scrivi” - un pulsante CmdEsci recante le dicitura “Esci”. - una textbox denominata TxNome recante la scritta “Paolo” Chiudere il progetto salvandolo come c:CorsoVbPrjMioPrimoProgetto P.S. per sottolineare le lettere dei bottoni (richiamabili con il tasto funzione ALT) occorre far precedere la lettera dal simbolo & (ad es. &Esci) ----------------------------------------------------------------------------------------------------------------- Operatore di Assegnazione Per assegnare un determinato valore ad una proprietà (da codice in fase di esecuzione) o, come vedremo successivamente, ad una variabile, occorre utilizzare l’operatore =. La proprietà si richiama antecedendo in nome dell’oggetto, seguito da un punto e poi dal nome della proprietà. Ad esempio, se vogliamo modificare il contenuto (proprietà text) di una casella di testo: TxNome.Text =“Marco” Evviva! Abbiamo scritto la prima istruzione! Ma dove l’andiamo a mettere? Come avevamo già accennato VB è un linguaggio Event-driven. Occorrerà quindi farla eseguire al verificarsi di un determinato evento. ----------------------------------------------------------------------------------------------------------------- Se, ad esempio, volessimo eseguirla facendo click sul pulsante CmdScrivi occorre intercettare l’evento Click del pulsante. Se dalla finestra di progettazione facciamo doppio click sul bottone CmdScrivi, si aprirà automaticamente l’editor di codice. Verrà già proposto in automatico da Vb l’evento predefinito del controllo (in questo caso, e per molti altri controlli, è il click); nella riga vuota potremo inserire la nostra istruzione: Private Sub CmdScrivi_Click() TxNome.Text = "Marco" End Sub Facile vero?? La prossima volta faremo ancora meglio!! ---------------------------------------------------------------------------------------------------------------- Nella scorsa lezione abbiamo visto il primo evento e la nostra prima istruzione. Approfondiremo gli eventi fra qualche lezione anche ci capiterà di doverne introdurre altri durante gli esempi. In questa lezione verrà affrontato, invece, il concetto di metodo. Le procedure e le funzioni. Procedure e funzioni (denominate anche subroutine e function) non sono altro che un gruppo di istruzioni, raccolte insieme, in modo da dare maggiore leggibilità al programma o per evitare di doverle ripetere in più. La differenza sostanziale tra le due è che le funzioni restituiscono un valore, mentre le procedure no. Avremo modo di approfondirle in seguito, per il momento ci basta il concetto. ---------------------------------------------------------------------------------------------------------------- Il comando Msgbox, Per permetterci di creare esempi più significativi, è d’obbligo introdurre una funzione fornita da Visual Basic che si chiama MsgBox (ovvero “Message Box”). Ne capiremo meglio in futuro la sintassi, per ora ci basti sapere che serve per far apparire una piccola finestra contente un messaggio esplicativo o di avvertimento. Per il momento avrà solo un tasto OK di conferma, ma vedremo come si farà a visualizzarla con altri tasti. Potremo specificare varie cose (parametri) a questa funzione, la prima è la frase (denominata anche stringa, ovvero una sequenza di caratteri alfanumerici) che vogliamo visualizzare, per conoscere le altre dovremo attendere ancora qualche lezione. La frase va indicata tra virgolette. Ad esempio, la seguente riga di codice MsgBox “frase da visualizzare” Crea una piccola finestra contenente un tasto OK e la frase “frase da visualizzare”. ---------------------------------------------------------------------------------------------------------------- I metodi. I metodi sono procedure (o funzioni) che appartengono ad un oggetto. Ad esempio una FORM possiede molti metodi che ci permettono di eseguire delle azioni su di essa: esiste un metodo per aprire la finestra, ne esiste uno che permette di nasconderla e così via. Per richiamare i metodi di un oggetto dal codice, occorre anteporre il nome dell’oggetto seguito da un punto e poi il nome del metodo. Ad esempio, il metodo che permette di mostrare una finestra si chiama SHOW; se supponiamo di avere una finestra che si chiama FrmMiaFinestra, per visualizzarla occorre inserire la seguente riga di codice: FrmMiaFinestra.Show ---------------------------------------------------------------------------------------------------------------- Il metodo show, Il metodo SHOW permette di visualizzare una finestra ancora inesistente (mai istanziata) oppure nascosta temporaneamente. Capiremo meglio in futuro la distinzione tra i due casi. Una finestra può essere visualizzata in modalità normale oppure modale. Le finestre modali sono denominate anche form a scelta obbligatoria e ci obbligano a dare una conferma (ad esempio cliccando su OK) per poterle chiudere o per passare ad altre finestre: per specificare questa modalità occorre mettere un 1 preceduto da uno spazio dopo la parola SHOW. In generale le istruzioni da utilizzare sono: NomeForm.Show (per finestre non modali) oppure NomeForm.Show 1 (per finestre modali) ----------------------------------------------------------------------------------------------------------------- L’oggetto ME, La parola chiave Me consente di far riferimento all’oggetto specifico che è in esecuzione in un determinato momento, ad esempio, riprendendo l’esempio precedente, se la riga di codice riportata sopra, fosse inserita all’interno del modulo della FrmMiaFinestra, cioè in un suo evento, potrei richiamare un suo metodo semplicemente anteponendo la parola chiave ME: Me.show Per oggi è tutto, la prossima lezione vedremo i principali metodi della Form e di altri controlli. ---------------------------------------------------------------------------------------------------------------- In questa lezione vedremo i principali metodi della Form e di altri controlli. Metodi principali dell’oggetto Form Print scrive del testo sulla parte grigia della Form (background), ad esempio: Me.Print “Frase” Cls cancella la grafica e il testo generati in fase di esecuzione da un oggetto Form Me.Cls Circle Disegna un cerchio sulla Form specificandone le coordinate del centro (partendo dall’angolo in alto a sinistra della finestra) e la lunghezza del raggio (in twips), ad esempio la seguente istruzione disegna un cerchio di raggio 200 twips lasciando 250 twips a sinistra e 400 twips sopra: Me.Circle (250, 400), 200 ---------------------------------------------------------------------------------------------------------------- Line Disegna linee o rettangoli sulla Finestra. Occorre indicare i due estremi (della linea oppure della diagonale del rettangolo) e specificare, inserendo la lettera B alla fine, se si vuole disegnare un rettangolo, ad esempio: Me.Line (250, 400)-(550, 400), vbRed disegna una linea orizzontale rossa Me.Line (250, 400)-(550, 800), vbGreen, B disegna un rettangolo verde. Dopo le coordinate degli estremi occorre indicare il colore che si vuole utilizzare (se non si specifica diversamente è il nero): i colori in VB sono rappresentati da un numero esadecimale (in generale in Windows) o da alcune costanti fornite dall’ambiente. Le costanti dei colori più usati sono vbWhite, VbBlack, VbRed, VbBlue, ecc.. ---------------------------------------------------------------------------------------------------------------- Hide Permette di nascondere la finestra “tenendola in vita”. Un form nascosto è invisibile ma rimane in memoria per essere usato in seguito. Me.Hide Le istruzioni Load e Unload L’istruzione Load viene usata per caricare un form in memoria per poi potervi accedere usando le istruzioni specificate nelle procedure di eventi. Dopo aver caricato un form è possibile utilizzarlo in qualsiasi procedura di eventi nel programma e si può accedere a qualsiasi sua proprietà e metodo. Load NomeFinestra L’istruzione contraria permette invece di scaricarlo dalla memoria (ed anche a chiuderlo se era visualizzato). Un form scaricato viene rimosso dalla memoria. Unload NomeFinestra -------------------------------------------------------------------------------------------------------------- Show Come avevamo già spiegato nella precedente lezione, permette di visualizzare una finestra (in modo modal o modless). Se non era ancora stata caricata tramite l’istruzione Load, il metodo Show si occupa di farlo in modo automatico Me.Show I metodi principali degli altri controlli Move Muove l’oggetto nella posizione indicata potendo specificare coordinata sinistra (left), superiore (top), larghezza ed altezza (sempre in twips). Ad esempio la seguente istruzione sposta il pulsante CmdEsci nella posizione 200 (distanza dal bordo sinistro della finestra che lo contiene),400 (dall’alto) ridimensionandolo a 1800 twips di larghezza e 1000 di altezza. CmdEsci.Move 200,400,1800,1000 ----------------------------------------------------------------------------------------------------------------- SetFocus posiziona il focus (*) sul controllo indicato, ad esempio l’istruzione che segue posiziona il focus sul pulsante CmdAnnulla CmdAnnulla.SetFocus Ora che abbiamo imparato i principali metodi degli oggetti, dove li andiamo a richiamare?? Se volete scoprirlo non perdetevi la prossima puntata: “Gli eventi” !! (*) Cos’è il focus? Ne avevamo già parlato nella prima lezione: un controllo ha il focus quando è pronto per ricevere il prossimo evento. In una casella di testo lo possiamo verificare perché al suo interno c’è il cursore che lampeggia, un pulsante invece appare circondato da un sottile rettangolo. ---------------------------------------------------------------------------------------------------------------- In questa lezione capiremo cosa sono gli eventi. e quali sono i principali. Gli eventi Abbiamo già anticipato nelle prime lezioni che gli eventi sono le azioni che il gestore è in grado di intercettare (click con il tasto sinistro del mouse, attivazione di una finestra, ecc.). Poiché Visual Basic è un linguaggio di tipo event-driven, saranno i nostri eventi a determinare l’ordine con cui verranno eseguite le istruzioni. Dunque noi potremo “programmare” gli eventi di un oggetto che riteniamo opportuni, ad esempio, l’evento click di un pulsante è bene che faccia qualcosa perché l’utente si aspetta che sia così… Se dalla finestra di progettazione facciamo doppio click su un oggetto, ad esempio su un pulsante, verrà creata in automatico una procedura di evento vuota per l’evento predefinito di quell’oggetto: nel caso del pulsante sarà il click. --------------------------------------------------------------------------------------------------------------- Le istruzioni che devono essere eseguite in risposta all'evento vanno inserite nello spazio compreso fra le righe generate automaticamente cioè tra la riga contenente l’inizio della procedura (SUB … ) e la riga che contraddistingue la fine della procedura di evento (END SUB). Ad esempio, in seguito alla pressione del pulsante CmdSaluta, verrà visualizzato il messaggio CIAO: Sub CmdSaluta_Click () MsgBox "Ciao" End Sub Principali eventi della Form Activate E’ l’evento che scatta quando la finestra diventa attiva (e la barra del titolo diventa blu) e è intercettato dal gestore di eventi solo la finestra è visibile. Initialize Occorre quando viene creata la prima volta un’istanza della finestra. ---------------------------------------------------------------------------------------------------------------- Load Scatta immediatamente dopo l’initialize, cioè quando la finestra viene caricata. In questo evento si potrebbero eventualmente pulire tutte le caselle di testo e sistemare altre proprietà dei controlli. Click e DblClick Inutile spiegare che sono gli eventi intercettati facendo click e doppio click con il pulsante sinistro del mouse su un punto vuoto della finestra MouseDown e MouseUp Questi due eventi occorrono immediatamente prima (e dopo) del click, cioè quando viene abbassato e rilasciato il pulsante sinistro del mouse su un punto della finestra. MouseMove Evento che scatta muovendo il mouse sulla finestra. KeyDown e KeyUp Intercettano la pressione e il rilascio di un tasto della tastiera (compresi i tasti funzione). Approfondiremo l’utilizzo di questi due eventi nella prossima lezione. ---------------------------------------------------------------------------------------------------------------- Paint Occorre ogni qualvolta la finestra di deve disegnare, quindi la prima volta che diventa visibile, quando viene allargata, ridotta ad icona e poi ingrandita ecc. Resize E’ facilmente intuibile che questo evento si scateni ogni volta che cambiano le dimensioni della finestra. QueryUnload Scatta appena prima dell’evento Unload e solitamente lo si usa per non uscire da una finestra per sbaglio. Private Sub Form_QueryUnload(Cancel As Integer, UnloadMode As Integer) If MsgBox("Sei sicuro di voler uscire?", vbYesNo) = vbNo Then Cancel = True End If End Sub Unload ---------------------------------------------------------------------------------------------------------------- E’ ultimo evento in ordine temporale e si scatena quando la finestra viene scaricata dalla memoria (cioè quando eseguiamo l’istruzione Unload). Quando carichiamo in memoria la finestra (cioè la creiamo ed instanziamo) e poi la visualizziamo, scattano una serie di eventi in sequenza uno dopo l’altro. Per ricordarci questa successione ci viene in aiuto una semplice frase … I Love RAP che sta ad indicare Initialize, Load, Resize, Activate e Paint. Per conoscere gli eventi degli altri controlli non perdetevi la seconda puntata su “Gli eventi” !! ----------------------------------------------------------------------------------------------------------------- n questa lezione vedremo quali sono i principali eventi dei controlli. Click e DblClick Eventi che occorrono facendo click e doppio click con il pulsante sinistro del mouse su un punto vuoto della finestra Change Occorre quando il testo (proprietà text) del controllo viene modificato. GotFocus Questo evento viene intercettato quando il controllo riceve il focus. LostFocus Scatta alla perdita del focus. ----------------------------------------------------------------------------------------------------------------- KeyPress Occorre digitando un tasto della tastiera. Restituisce un valore che rappresenta il codice ASCII del tasto digitato. Questo evento si utilizza in molte situazioni, ad esempio se si vuole convertire automaticamente in maiuscolo ciò che l’utente sta digitando. KeyDown e KeyUP Occorrono immediatamente prima (e dopo) del KeyPress: alla pressione e al rilascio di un tasto. Questi due eventi sono indispensabili per intercettare la digitazione di un tasto funzione. MouseDown e MouseUp Questi due eventi occorrono immediatamente prima (e dopo) del click, cioè quando viene abbassato e rilasciato il pulsante sinistro del mouse quando si fa click sul controllo. MouseMove Evento che scatta muovendo il mouse sul controllo. --------------------------------------------------------------------------------------------------------------- Naturalmente esistono altri eventi, specifici di ogni controllo. Per il momento accontentiamoci di imparare i principale e di volta in volta affronteremo i nuovi. Per poter programmare gli eventi occorre conoscere le basi di programmazione del linguaggio BASIC: i costrutti, le variabili, le costanti, gli operatori, le procedure e le funzioni. Questi saranno gli argomenti che affronteremo le prossime lezioni, ma per poter capire un importante esempio di utilizzo degli eventi introduciamo la struttura di controllo IF. Ma cos’è una struttura di controllo? E’ un elemento del linguaggio che permette di controllare il flusso delle istruzioni. Infatti abbiamo detto che le istruzioni che diamo a Visual Basic vengono eseguite se si verifica un certo evento, e, all’interno della procedura di evento, le istruzioni vengono eseguite una dopo l’altra a meno che si faccia uso di questi strumenti. Le strutture quindi modificano la sequenza delle istruzioni eseguite in base al verificarsi di un certa condizione (strutture di controllo o decisionali) oppure permettono di ripetere un certo numero di istruzioni (cicli). ---------------------------------------------------------------------------------------------------------------- La struttura decisionale IF Se il programma deve prendere delle decisioni, Visual Basic prevede la struttura If (presente, tra l’altro, in quasi tutti i linguaggi) caratterizzata dalla seguente sintassi: If Then [Else ] End If La condizione può essere rappresentata da un’ espressione logica, cioè un’espressione che dà come risultato vero o falso. Se essa è verificata viene eseguito il blocco di istruzioni indicato fra le parole chiave Then e Else. In caso contrario, è eseguito il secondo gruppo di istruzioni. Si noti che quest'ultimo può anche essere assente. In tal caso, la parola chiave Else non va utilizzata e non è eseguito alcun codice in caso di mancata verifica della condizione. La frase End If delimita la struttura. --------------------------------------------------------------------------------------------------------------- Esempio Per visualizzare un messaggio diverso a seconda che un saldo sia positivo o negativo: Private Sub CmdCalcola_Click() IF Saldo > 0 then MsgBox “Saldo positivo” else MsgBox “Saldo negativo” End If End Sub Dopo questa dovuta premessa siamo in grado di capire meglio l’esempio di utilizzo dell’evento KeyPress di una casella di testo. Queste semplici righe di codice ci permettono di utilizzare anche il tasto INVIO per passare da una casella all’altra, oltre che il tasto TAB (quello predefinito di Window). ----------------------------------------------------------------------------------------------------------------- n pratica viene verificato se il codice ASCII del tasto premuto corrisponde a quello dell’invio (13) e, in tal caso, viene simulata la pressione del TAB utilizzando un apposito comando di Visual Basic denominato SendKeys. Private Sub Text1_KeyPress(KeyAscii As Integer) If KeyAscii = 13 Then SendKeys "{tab}" KeyAscii = 0 End If End Sub Dalle prossime lezioni entreremo nel vivo del linguaggio, imparando gli elementi fondamentali alla base della programmazione. Ci addentreremo nel “cuore” del linguaggio: gli elementi base di programmazione. ---------------------------------------------------------------------------------------------------------------- Eccoci arrivati alla prima lezione di programmazione vera e propria! Le variabili Anche Visual Basic, come tutti i linguaggi di programmazione, prevede l'uso delle variabili. Una variabile è un luogo di memorizzazione temporanea per i dati del programma a cui esso può accedere grazie a un nome assegnato in fase di creazione. Si possono utilizzare più variabili all’interno del codice ed esse possono contenere diversi tipi di dati quali numeri, lettere, date o addirittura oggetti. Solitamente prima di utilizzare una variabile occorrerebbe crearla; questa prassi è obbligatoria in quasi tutti i linguaggi, mentre Visual Basic, essendo poco “pignolo” ci permette anche di non farlo. Il consiglio è comunque quello di impostare una maggiore rigidità per avere più controllo in fase di compilazione e quindi evitare errori di distrazione: abilitando la voce “Dichiarazione di variabili obbligatoria” nel menù Strumenti, Opzioni. ----------------------------------------------------------------------------------------------------------------- Dichiarazione di una variabile Per dichiarare una variabile occorre utilizzare l’istruzione Dim, che presenta la seguente sintassi: Dim [As ] in cui rappresenta il nome da assegnare alla variabile e rappresenta il tipo di dato che la variabile conterrà. Non è obbligatorio specificare un tipo di dato, ma è consigliabile farlo per ottimizzare l’impiego delle risorse. Esempio: Dim Importo as Integer ---------------------------------------------------------------------------------------------------------------- Regole di assegnazione del nome di una variabile Il nome di una variabile deve essere costituito da una sequenza di caratteri alfabetici o numerici nel rispetto delle seguenti regole: - deve iniziare sempre con una lettera - non può contenere spazi - può contenere al massimo 256 carattere - non deve essere una parola chiave, il nome di una proprietà o di un oggetto di Visual Basic - può contenere il carattere _ (underscore) - non vi è differenza tra maiuscole e minuscole (la variabile Somma è anche SOMMA) Esempi di nomi corretti: Somma_Num, Stringa1, TOTALE Esempi di nomi errati: 1Totale, Data Pagamento, Print, You&Me, _Totale ----------------------------------------------------------------------------------------------------------------- Tipi di dato in Visual Basic Abbiamo detto che è consigliabile, anche se non obbligatorio dare un'indicazione del tipo di dato da creare. Visual Basic prevede numerosi tipi standard. I più utilizzati sono: - byte tipo numerico intero senza segno compreso nell’intervallo da 0 a 255 - integer usato per rappresentare numeri interi (con segno) compresi fra -32768 a 32767 - string che può contenere delle sequenze di caratteri (stringhe) a lunghezza variabile oppure a lunghezza fissa - long per numeri interi compresi fra -2,147,483,648 e 2,147,483,647, - single e double, con cui è possibile memorizzare numeri reali a singola o a doppia precisione - boolean, tipo logico che può assumere il valore TRUE o FALSE (vero o falso) - date, in cui è possibile memorizzare data e ora - variant, tipo universale che può contenere dei dati di qualsiasi formato ----------------------------------------------------------------------------------------------------------------- Se una variabile non è dichiarata, la sua creazione avviene la prima volta in cui si fa riferimento ad essa. In assenza di dichiarazione (dichiarazione implicita) oppure in caso di dichiarazione senza la specifica del tipo, Visual Basic considera il tipo di dato della variabile come Variant (con conseguente spreco di risorse), a meno che si utilizzi un carattere identificatore di tipo alla fine del nome della variabile. I principali identificatori di tipo sono i seguenti: $ per String % per tipo di dato Integer & per tipo di dato Long ! per tipo di dato Sigle, # per tipo di dato Double Ad esempio, è possibile creare una variabile di tipo numerico intero ed assegnarle un valore scrivendo le due seguenti istruzioni Dim Importo as Integer Importo = 1000 oppure con la sola dichiarazione implicita Importo% = 1000 ----------------------------------------------------------------------------------------------------------------- Assegnazione di un valore ad una variabile Per assegnare un determinato valore ad una variabile, occorre utilizzare l’operatore =, lo stesso che abbiamo utilizzato per cambiare i valori delle proprietà delle form e dei controlli. Dim MyVar as string MyVar=“Ciao” Variabili locali Le variabili possono essere create all’interno di una procedura di evento. In tal caso si chiamano variabili locali in quanto nascono all’atto della dichiarazione e vengono distrutte dopo l'esecuzione dell'ultima istruzione. Private Sub Command1_Click() Dim Messaggio As String . . . End Sub Per fare in modo che il loro valore sia conservato durante tutta l’esecuzione del programma e che siano visibili anche dentro ad altre procedure occorre creare variabili diverse che studieremo nella seconda parte di “Le variabili”. Dunque non mancate alla prossima lezione!! ---------------------------------------------------------------------------------------------------------------- Avevamo detto nella scorsa lezione che se dichiariamo le variabili localmente all’interno di una procedura di evento, esse nascono quando va in esecuzione l’evento e muoiono al termine di esso. Le variabili possono anche appartenere a tutte le procedure evento di una stessa finestra oppure essere comuni e visibili a tutte le finestre del nostro progetto, in tal caso occorre dichiararle in modo diverso. Variabili pubbliche all’interno di un Form Se abbiamo bisogno di una variabile che mantenga il valore (ossia non “muoia” al termine di un evento) e sia visibile all’interno di tutto il Form, occorrerà dichiararla nella parte più alta della finestra del codice del Form, ovvero prima di tutte le procedure di evento. ---------------------------------------------------------------------------------------------------------------- Dim Importo as long Private Sub … …. End Sub Private Sub … …. End Sub ……. Se vogliamo che questa variabile sia utilizzata anche da altre Form, occorre dichiararla, nella stessa posizione, utilizzando la parola chiave Public. In questo modo, le altre finestre, per fare riferimento ad essa devono far precedere il nome della finestra a quello della variabile (separato da un punto), perché la variabile appartiene alla finestra ed esiste solo se la finestra è caricata in memoria. Ad esempio, per utilizzare la variabile pubblica Importo della finestra FrmInvoice dalla finestra FrmCustomer, occorre utilizzare la seguente sintassi: TxSomma = FrmInvoice.Importo ----------------------------------------------------------------------------------------------------------------- Variabili globali Quando si presenta la necessità di fare in modo che un valore sia accessibile da tutte le procedure presenti nell'applicazione, indipendentemente dal form in cui esse si trovano, e che questa variabile non appartenga a nessuna Form in particolare, è necessario utilizzare per la dichiarazione la parola chiave Global. Una variabile dichiarata in questo modo è detta globale. La sua dichiarazione non può essere fatta all'interno di un form (proprio perché deve essere indipendente da ognuno di essi), ma deve essere effettuata in un modulo. E’ molto semplice, basta utilizzare la parola chiave Global (va bene anche Public) anziché Dim e mettere l’istruzione all’interno di un modulo. Esempio di dichiarazione di una variabile globale all’interno di un modulo: Global Autore as String ----------------------------------------------------------------------------------------------------------------- I moduli I moduli standard (o moduli di codice) sono componenti del progetto che contengono del codice puro (vengono memorizzati su disco con estensione .BAS), ovvero non contengono parti grafiche e possono contenere dichiarazioni di variabili, procedure e funzioni. Solitamente vengono utilizzati per contenere le funzioni e le variabili comuni a tutte le finestre, un sorta di “libreria” per intenderci. Per aggiungere un modulo al progetto scegliere, dal menù Progetto, la voce Inserisci Modulo. Il modulo ha una proprietà Name, inputabile dalla solita finestra delle proprietà. Con tale nome il modulo verrà visualizzato, insieme alle Form, nella finestra del progetto. Quel nome, inoltre, è anche quello che ci viene proposto in fase di salvataggio su disco del file. Esempio Se aggiungiamo un modulo che chiamiamo Libreria, in fase di salvataggio del progetto ci verrà proposto da Visual Basic di salvarlo nella directory dove già è memorizzato il progetto, con il nome LIBRERIA.BAS, eventualmente modificabile. ---------------------------------------------------------------------------------------------------------------- La InputBox Per far immettere all’utente dei valori, si possono utilizzare le caselle di testo all’interno di una finestra, oppure si può utilizzare una funzione (ossia un’istruzione che restituisce un risultato) che ci mette a disposizione Visual Basic: la InputBox. E’ molto simile alla MsgBox (ricordate ??), apre una piccola finestrina con un messaggio, con la differenza che dà la possibilità di inserire del testo. Possiamo specificare la frase da visualizzare ed il titolo elencandoli tra parentesi e virgolette. Essa ci restituisce poi un risultato che possiamo memorizzare in una variabile. Questo esempio memorizza nella variabile Frase ciò che l’utente ha digitato nella finestrina avente il titolo “Prova” a destra della dicitura “Inserisci una frase”: Frase = InputBox( “Inserisci una frase”, “Prova”) Se l’utente digita “Ciao” la variabile Frase conterrà “Ciao”. ----------------------------------------------------------------------------------------------------------------- Applicazione di esempio Il listato di codice che segue rappresenta un piccolo progetto che all’avvio della Form1 chiede il nome dell’autore della procedura, lo memorizza in una variabile globale Autore. Nella Form2, dal pulsante “Informazioni”, è possibile visualizzare il nome dell’autore del programma. Per provarlo è sufficiente creare un nuovo progetto, aggiungere una seconda Form al progetto, aggiungere un Modulo, mettere un pulsante CmdApriFinestra sulla Form1 e un pulsante CmdInfo sulla Form2, copiare il codice qui sotto… ed il gioco è fatto!!! ‘ Codice da inserire nel modulo Global Autore As String ‘ Codice da inserire nella Form1 Private Sub CmdApriFinestra_Click() Form2.Show End Sub Private Sub Form_Load() Autore = InputBox("Inserire il nome dell'autore del progetto", "Attenzione") End Sub ‘ Codice da inserire nella Form2 Private Sub CmdInfo_Click() MsgBox Autore End Sub Facile vero??? La prossima lezione diventeremo ancora più bravi!! ----------------------------------------------------------------------------------------------------------------- Prima di passare ad esaminare le strutture di controllo, è opportuno conoscere gli operatori che si possono utilizzare per formulare espressioni o condizioni. Gli operatori matematici Primi tra tutti sono gli operatori matematici. Le quattro operazioni fondamentali esistono, naturalmente, con la sola differenza che il simbolo di moltiplicazione è * e quello di divisione è / (in generale come in tutti i linguaggi di programmazione). Esistono inoltre altri tre operatori che permettono di determinare la parte intera o il resto di una divisione e per elevare un numero a potenza. Tutte le altre funzioni matematiche (radice quadrata, funzioni trigonometriche, ecc..) esistono in VB ma non sono operatori, bensì funzioni appartenenti ad una libreria. ----------------------------------------------------------------------------------------------------------------- + Somma Somma i valori - Sottrazione Sottrae i valori * Moltiplicazione Moltiplica i valori / Divisione Divide i valori Divisione intera Determina la parte intera di una divisione ^ Esponente Eleva un valore ad una potenza MOD Modulo Determina il resto di una divisione Esempi: 5 + 8 = 13, 12 - 4 = 8, 3 * 6 = 18, 10 / 3 = 3,33.., 10 3 = 3, 2 ^ 3 = 8, 10 MOD 3 = 1 Esempi in VB: Importo = Numero1 + Numero2, Importo = Num1 * Num2, Quadrato = Num ^ 2, Resto = Num1 MOD Num2 Operatori di relazione (o confronto) Gli operatori di relazione sono indispensabili per confrontare dei valori numerici (e non) e quindi per esprimere delle condizioni, e sono: = Uguale > Maggiore >= Maggiore uguale < Minore <= Minore uguale <> Diverso Esempi: Numero1 <> Numero2, Importo1 < = Importo2 --------------------------------------------------------------------------------------------------------------- Gli operatori logici Gli operatori logici permettono di concatenare tra loro più condizioni e quindi di creare condizioni composte (ricordate?! le condizioni le abbiamo già viste nella struttura di controllo o IF.. che approfondiremo nuovamente la prossima lezione) AND la condizione è vera se entrambe le condizioni si verificano; è falsa se una od entrambe le condizioni non si verificano Esempio: Espressione1 AND Espressione2, dà risultato TRUE solo nel caso in cui entrambe le espressioni diano come risultato TRUE (cioè siano vere) TRUE and TRUE = TRUE TRUE and FALSE = FALSE FALSE and FALSE = FALSE FALSE and TRUE = FALSE ----------------------------------------------------------------------------------------------------------------- NOT è utilizzato per eseguire una negazione logica di un’espressione, cioè per esprimere una condizione al contrario. not TRUE = FALSE not FALSE = TRUE OR La condizione è vera al verificarsi di una od entrambe le condizioni, ad esempio: Espressione1 OR Espressione2, dà risultato TRUE nel caso in cui almeno una delle espressioni sia vera. TRUE or TRUE = TRUE TRUE or FALSE = TRUE FALSE or FALSE = FALSE FALSE or TRUE = TRUE In realtà esistono altri tre operatori logici meno utilizzati: Xor, Eqv, Imp, derivabili dai precedenti. ----------------------------------------------------------------------------------------------------------------- Ordine delle operazioni In un’espressione del tipo: Totale= Totale + Prezzo * Quantita, quali sono le operazioni eseguite prima? In generale questo è un problema che incontriamo anche in matematica ed è per questo motivo che a volte occorre fare uso delle parentesi. L’ordine in cui le considera Visual Basic è il seguente: - esponente - moltiplicazione, divisione, divisione intera, modulo - addizione e sottrazione - operatori di confronto (valutati da sinistra a destra) - operatori logici (nell’ordine NOT, AND, OR) Per modificare l’ordine delle operazioni occorre utilizzare le parentesi tonde (le quadre e le graffe, utilizzate nelle espressioni matematiche, non possono essere utilizzate). Anche per questa volta è tutto… non perdetevi la prossima! Continueremo le lezioni sui concetti di programmazione di base, in particolare sulle strutture di controllo. ---------------------------------------------------------------------------------------------------------------- Avevamo già anticipato nella lezione 9 cosa sono le strutture di controllo ed in particolare avevamo visto la struttura di controllo IF. La struttura decisionale o di controllo (o costrutto) è un elemento del linguaggio che permette di controllare il flusso delle istruzioni. Le istruzioni, in Visual Basic vengono eseguite se si verifica un certo evento, e, all’interno della procedura di evento, le istruzioni vengono eseguite una dopo l’altra a meno che si faccia uso di questi strumenti. Le strutture quindi modificano la sequenza delle istruzioni eseguite in base al verificarsi di un certa condizione oppure permettono di ripetere un certo numero di istruzioni. ------------------------------------------------------------------------------------------------------------- La struttura decisionale IF Il costrutto IF permette di eseguire una o più istruzioni in seguito al verificarsi di una condizione. If Then [Else ] End If La condizione può essere rappresentata da una espressione logica, cioè un’espressione che dà come risultato vero o falso. Se essa è verificata viene eseguito il blocco di istruzioni indicato fra le parole chiave Then e Else. In caso contrario, è eseguito il secondo gruppo di istruzioni. Si noti che quest'ultimo può anche essere assente. In tal caso, la parola chiave Else non va utilizzata e non è eseguito alcun codice in caso di mancata verifica della condizione. La frase End If delimita la struttura. --------------------------------------------------------------------------------------------------------------- Esempio Per visualizzare un messaggio diverso a seconda che un saldo sia positivo o negativo: Private Sub CmdVediSaldo_Click() IF Saldo > 0 then MsgBox “Saldo positivo” else MsgBox “Saldo negativo” End If End Sub Ciclo For.. Next Il costrutto FOR .. NEXT consente di ripetere un gruppo di istruzioni per il numero di volte specificato. For contatore = inizio To fine [Step incremento] [istruzioni] [Exit For] [istruzioni] Next [contatore] ----------------------------------------------------------------------------------------------------------------- Quando ci può servire un ciclo di questo tipo? Quando dobbiamo ripetere un certo numero di volte una stessa istruzione. Per definizione, nel costrutto FOR, dobbiamo utilizzare una variabile numerica intera (denominata contatore) che si incrementa ad ogni esecuzione del ciclo. Il contatore parte dal valore indicato dopo il simbolo = fino ad arrivare ad un valore massimo indicato dopo la parola chiave TO. L’incremento solitamente è 1, se serve un passo diverso (ad esempio 2) occorre aggiungere STEP 2 dopo il numero massimo. La fine del ciclo è identificata dalla parola chiave NEXT, immediatamente dopo si può indicare anche il nome della variabile contatore. Non è necessario, anche se solitamente è bene metterlo se si usano cicli FOR annidati (Suggerimento: nelle sintassi dei linguaggi solitamente la parentesi quadra indica parti opzionali!!). Esempio: il seguente ciclo visualizza i primi dieci numeri. E’ stata dichiarata una variabile che fa da contatore partendo dal numero 1 fino al numero 10 ---------------------------------------------------------------------------------------------------------------- Dim Conta as integer For Conta=0 to 10 Msgbox Str(Conta) Next Conta Esempio: calcolo del fattoriale di un numero N inserito dall’utente. Per definizione il fattoriale (si indica con il simbolo !) di un numero N è uguale a 1* 2 * 3 * …. * N, in formule: N! = 1* 2 * 3 * …. * N I passi seguiti sono: - richiesta del numero all’utente attraverso la funzione InputBox (vista nella lezione 11), memorizzato poi nella variabile N. - dichiarazione di una variabile contatore I (perché il fattoriale per definizione fa N moltiplicazioni, dunque il nostro ciclo dovrà dunque essere ripetuto N volte). - dichiarazione di una variabile Fattoriale, atta a contenere il risultato finale e parziale di ogni moltiplicazione; notare che occorre inizializzarla a 1 in quanto è l’elemento neutro della moltiplicazione. ---------------------------------------------------------------------------------------------------------------- Private Sub CmdFatt_Click() Dim N As Integer Dim I As Integer Dim Fattoriale As Long Fattoriale = 1 N = InputBox("Inserisci il numero:", "Calcolo del fattoriale") For I = 1 To N Fattoriale = Fattoriale * I Next I MsgBox "Il fattoriale di " & Str(N) & " é " & Str(Fattoriale) End Sub La prossima volta vedremo un altro costrutto che permette di eseguire dei cicli. Per il momento ci accontentiamo di assimilare il FOR e terminiamo la lezione introducendo un’altra struttura di controllo meno utilizzata. ---------------------------------------------------------------------------------------------------------------- L’istruzione Go To Passa incondizionatamente a una riga specifica all'interno di una procedura (ma non al di fuori di essa) ed identificata da un’etichetta. Per definire un ‘etichetta è sufficiente darle un nome (seguito dai : ) e posizionarla nel punto desiderato. GoTo etichetta Esempio: Private Sub CmdSaluta_Click() Msgbox “Adesso vi saluto” GoTo SALUTA … … SALUTA: Msgbox “Ciao a tutti” End Sub Suggerimento: la presenza di troppe istruzioni GoTo può rendere difficile la lettura del codice. Quando possibile, è consigliabile utilizzare istruzioni di controllo strutturate (Do...Loop, For...Next, If...Then...Else, Select Case) ----------------------------------------------------------------------------------------------------------------- Terminiamo oggi la parte relativa alle strutture di controllo introducendo gli ultimi due costrutti. Cicli Do While.. Loop e Do Until .. Loop La struttura Do...Loop consente di eseguire un blocco di istruzioni per un numero di volte imprecisato (contrariamente al FOR). L'istruzione Do...Loop valuta una condizione che consente di determinare se continuare o meno l'esecuzione. Come per la struttura If...Then, la condizione deve essere rappresentata da un valore o da un'espressione che risulti Vera o Falsa. La parola chiave DO identifica l’inizio del ciclo, mentre LOOP indica la fine. Esistono 4 varianti del ciclo Do…Loop; le prime due sono determinate dalla differenza tra While ed Until. In presenza di un While un ciclo viene eseguito fino a che la condizione risulta Vera; non appena la condizione diventa falsa, il ciclo viene interrotto. --------------------------------------------------------------------------------------------------------------- Viceversa l’Until viene eseguito finchè la condizione non è verificata ed è interrotto non appena diventa Vera. E‘ possibile diversificare ulteriormente il ciclo Do..Loop mettendo la condizione all’inizio (dopo il DO) oppure alla fine, dopo la parola chiave LOOP, la differenza sostanziale è che, mettendo la condizione alla fine, il ciclo viene eseguito sicuramente almeno una volta anche se la condizione di partenza non è Vera. Abbiamo dunque ottenute le seguenti combinazioni: Do While condizione Do Loop Loop While condizione Do Until condizione Do Loop Loop Until condizione ----------------------------------------------------------------------------------------------------------------- Esempio: stampiamo CIAO finchè l’utente non risponde NO alla domanda “Vuoi stampare?” nei quattro possibili casi: Private Sub CmdStampa_Click() Do While (MsgBox("Vuoi stampare?", vbYesNo) = vbYes) Print "CIAO" Loop End Sub Lo stesso risultato si ottiene utilizzando il DO UNTIL e quindi negando la condizione precedente Do Until (MsgBox("Vuoi stampare?", vbYesNo) = vbNo) Print "CIAO" Loop Un risultato leggermente diverso lo possiamo avere mettendo la condizione alla fine: nei due casi precedenti CIAO non viene stampanto se l’utente risponde NO alla prima domanda, mettendo la condizione alla fine, CIAO viene stampato sicuramente almeno una volta: ---------------------------------------------------------------------------------------------------------------- Do Print "CIAO" Loop While (MsgBox("Vuoi stampare?", vbYesNo) = vbYes) Do Print “CIAO” Loop Until (MsgBox("Vuoi stampare?", vbYesNo) = vbNo) Utilizzando il ciclo Do..Loop è possibile riprodurre il costrutto FOR, in questo caso ovviamente, bisogna farsi carico di inizializzare ed incrementare il contatore. Esempio: riprendiamo il ciclo che visualizza i numeri da 0 a 10 Dim Conta as integer Conta=0 Do While Conta <= 10 Msgbox Str(Conta) Conta=Conta+1 Loop ATTENZIONE! In cicli di questo tipo è bene non dimenticarsi l’incremento del contatore, in tal caso, infatti, la condizione non diventa mai Vera e si genera un LOOP INFINITO. ---------------------------------------------------------------------------------------------------------------- L’istruzione Select Case Select Case è analogo a If...Then...Else, ma è più indicato e migliora la leggibilità del codice nel caso di più scelte. Si basa su un'unica espressione di prova che viene valutata una volta all'inizio della struttura stessa. Il risultato di tale espressione viene confrontato con il valore di ciascuna istruzione Case della struttura e in caso di corrispondenza viene eseguito il blocco di istruzioni associato all'istruzione Case: Select Case [Case [bloccoistruzioni-1]] [Case [bloccoistruzioni-2]] . .. [Case Else [bloccoistruzioni-n]] End Select ----------------------------------------------------------------------------------------------------------------- Esempio: La MsgBox (vedere approfondimento dopo) può restituire 3 risultati differenti (esempio SI, NO, ANNULLA), in tal caso avremmo bisogno di 2 costrutti IF per valutare le istruzioni da eseguire. In tal caso è consigliabile utilizzare il Select..Case Private Sub CmdProva_Click() Dim Ris As Integer Ris = MsgBox("Che tasto hai scelto", vbYesNoCancel) Select Case Ris Case vbYes Msgbox “SI” Case vbNo MsgBox "NO" Case vbCancel MsgBox "ANNULLA" Case Else End Select End Sub ----------------------------------------------------------------------------------------------------------------- Approfondimenti sulla Msgbox Avevamo anticipato la MsgBox (lezione 6) alla quale possiamo indicare la frase da visualizzare. Oltre a questa frase, possiamo specificare altre caratteristiche (denominate parametri). La sua sintassi completa è: MsgBox(prompt[, buttons] [, title] [, helpfile, context]) Dove: Prompt è la frase che viene visualizzata. buttons è un valore numerico (solitamente rappresentato da costanti fornite dal linguaggio) che rappresenta i bottoni che saranno visualizzati (esempio SI, No, OK, Annulla). Se è omesso vale 0, ovvero visualizza il solo tasto OK. Alcuni possibili valori sono: vbOKOnly (equivale al numero 0) visualizza solo il pulsante OK. VbOKCancel ( “ “ 1) visualizza i pulsanti OK e Annulla. VbAbortRetryIgnore ( “ “ 2) visualizza i pulsanti Termina, Riprova, e Ignora. VbYesNoCancel ( “ “3) visualizza i pulsanti Sì, No e Annulla. VbYesNo ( “ “ 4) visualizza i pulsanti Sì e No. Title è la frase visualizzata nella barra del titolo della finestra di dialogo; se viene omesso verrà indicato il nome dell'applicazione. Help e context servono nel caso in cui il nostro programma preveda una guida in linea. ---------------------------------------------------------------------------------------------------------------- Msgbox è una funzione e come tale, restituisce un valore. Il valore restituito dalla funzione MsgBox corrisponde al tasto scelto dall’utente tra quelli visualizzati. I possibili valori che può assumere sono: vbOK (equivale al numero 0) e corrisponde alla scelta del pulsante OK vbCancel ( “ “ 2) “ “ “ “ Annulla vbAbort ( “ “ 3) “ “ “ “ Termina vbRetry ( “ “ 4) “ “ “ “ Riprova vbIgnore ( “ “ 5) “ “ “ “ Ignora vbYes ( “ “ 6) “ “ “ “ Sì vbNo ( “ “ 7) “ “ “ “ No Finalmente conosciamo i costrutti che stanno alla base del linguaggio BASIC. La prossima volta ci aspetta un’altra “avventura”: le procedure e le funzioni. Non mancate! ---------------------------------------------------------------------------------------------------------------- Finalmente siamo oggi riusciamo ad approfondire il concetto di procedura e funzione che abbiamo dovuto anticipare piu’ volte. Procedure e funzioni (sottoprogrammi) servono per raccogliere un gruppo di istruzioni per dare maggiore leggibilità al programma o per evitare di ripetere in più punti le stesse istruzioni. La differenza sostanziale tra le due è che le funzioni restituiscono un valore, mentre le procedure no. Procedure Una procedura in Visual Basic prende il nome di Sub. La sintassi di dichiarazione di una procedura è la seguente Sub NomeProcedura([param1 as …, param2 as…]) istruzioni End Sub Ad esempio, se vogliamo creare una procedura che visualizza una frase di saluto: Sub Saluta() Msgbox “Ciao” End Sub ---------------------------------------------------------------------------------------------------------------- Per utilizzarla è sufficiente scrivere il nome della procedura: Private Sub Command1_Click() Saluta End Sub In questo caso non appare evidente l’utilità di utilizzare un procedura, ma se avessimo usato Saluta molte volte all’interno del nostro codice e ad un certo punto si presentasse la necessità di cambiare la frase “Ciao” per tradurla in inglese “Hello”, sarebbe sufficiente cambiarla una sola volta (all’interno della procedura). I parametri Nella sintassi di dichiarazione della procedura compaiono degli elementi racchiusi tra parentesi quadre: sono i parametri o argomenti, che già avevamo dovuto anticipare nelle prime lezioni. Non è obbligatorio utilizzarli (ed è per questo motivo che sono indicati tra parentesi quadre), ma sono molto utili in quanto a volte si vuole rendere “parametrica” la procedura (o la funzione). Occorre dare un nome ad ogni parametro e specificare il tipo di dato che conterrà (proprio come le variabili), se ne indichiamo più di uno occorre elencarli di seguito separati da virgola. L’ordine posizionale è anche quello che ci servirà per riferirci ad essi quando utilizziamo la procedura. ---------------------------------------------------------------------------------------------------------------- Ad esempio potremmo rendere parametrica Saluta mettendo come argomento il nome della persona che vogliamo salutare: Sub Saluta(Nome as string) Msgbox “Ciao ” + Nome End Sub In questo caso, per richiamarla occorrerà specificare anche il valore del parametro dopo il nome della procedura separato da spazio: Private Sub Command1_Click() Saluta “Carlo” End Sub Ampliando l’esempio a due parametri: Sub Saluta(Nome as string, Cognome as string) Msgbox “Ciao ” + Nome + “ “ + Cognome End Sub I parametri possono essere passati direttamente con il loro valore oppure utilizzando una variabile, come nell’esempio : Private Sub Command1_Click() Dim Surname as string Surname =”Rossi” Saluta “Carlo”, Rossi End Sub ----------------------------------------------------------------------------------------------------------------- Funzioni La funzione è analoga alla procedura, con la sola differenza che restituisce un valore. La sua dichiarazione è analoga a quella della Sub, ma occorre specificare la parola chiave Function ed indicare, dopo la parentesi tonda (alla fine dell’elenco dei parametri), l’indicazione del tipo di dato che restituirà. Function NomeFunction(param1 as …, ...) as ... Istruzioni NomeFUnction= End Function P.S.Poiché essa restituisce un valore sarà opportuno che tra le istruzioni che contiene ve ne sia almeno una che assegna alla funzione stessa il valore risultante!! Supponiamo, ad esempio di voler creare una funzione che calcola l’importo dell’IVA al 4% su un imponibile . L’imponibile sarà il nostro parametro ed il risultato sarà restituito dalla funzione stessa. Function IVA(Importo As Long) As Long IVA = Importo * 0.04 End Function ----------------------------------------------------------------------------------------------------------------- Per richiamare la funzione si usano le stesse regole della procedura, ma attenzione; i parametri vanno elencati tra parentesi !!. Dim ValoreIva As Long ValoreIva = IVA(100000) MsgBox "L'IVA al 4% su L.100.000 è:" + Str(ValoreIva) End Sub Per migliorare l’esempio possiamo rendere parametrico anche l’aliquota IVA, con il seguente risultato: Function IVA(Importo As Long, Aliquota As Single) As Long IVA = Importo * Aliquota / 1000 End Function Un’approfondimento: abbiamo detto che per richiamare una procedura occorre elencare i parametri senza utilizzare le parentesi. Esiste un altro modo: utilizzare l’istruzione Call: Call Saluta(“Carlo”) In tal caso le parentesi vanno utilizzate!! Tutto chiaro? Per il momento è tutto anche se l’argomento “Procedure e Funzioni” ci riserverà ancora qualche sorpresa: alla prossima, non mancate! ---------------------------------------------------------------------------------------------------------------- l passaggio di parametri Nella scorsa lezione abbiamo visto cosa sono le procedure, le funzioni ed i parametri, in particolare avevamo detto che i parametri hanno un’ordine posizionale, vanno elencati separati da virgola, devono rispettare il tipo di dato specificato nella dichiarazione e possono essere “passati” come valori fissi o tramite variabili. Cerchiamo di approfondire meglio quest’ultimo concetto. E’ possibile passare dei parametri alle procedure ed alle funzioni in due modi: - passaggio per riferimento (ByRef ), si utilizza quando all’interno della procedura (o funzione) il valore del parametro viene modificato e, alla procedura chiamante, serve il valore di ritorno modificato; - passaggio per valore (ByVal), il valore del parametro, ritorna alla procedura chiamante con il suo valore originale, anche se viene modificato all’interno della procedura (o funzione). ----------------------------------------------------------------------------------------------------------------- Il passaggio per valore è più sicuro, ma lavora su una copia del valore del parametro, e dunque occupa più memoria. E’ per questo motivo che il passaggio di default (ovvero quello scelto da VB se non specificato diversamente) è quello per riferimento… anche se si dice che nella prossima versione di VB non sarà esattamente così… J Esempio Supponiamo di migliorare la funzione scritta la volta precedente: la nuova funzione dovrà verificare che l’aliquota IVA sia corretta ed in caso contrario dovrà restituire alla procedura chiamante l’aliquota con valore 0. Function IVA(Importo As Long, ByRef Aliquota As Single) As Long If (Aliquota <> 4) And (Aliquota <> 20) Then Aliquota = 0 Exit Function End If IVA = Importo * Aliquota / 1000 End Function ----------------------------------------------------------------------------------------------------------------- La funzione IVA verrà richiamata nell’evento click del pulsante Command1: Private Sub Command1_Click() Dim Aliquota As Single AliquotaIva = 5 Call IVA(100000, Aliquota) If AliquotaIva = 0 Then MsgBox "L'aliquota iva è sbagliata" Else MsgBox "L'aliquota iva rientra in quelle specificate" End If End Sub In questo caso la variabile AliquotaIva assumerà il valore 0 in seguito alla chiamata della funzione IVA permettendoci di capire che l’aliquota è sbagliata. Sostituendo la parola chiave ByVal nella funzione IVA: Function IVA(Importo As Long, ByRef Aliquota As Single) As Long ….. Otterremo un risultato differente, la variabile AliquotaIva varrà 5 anche al ritorno dalla chiamata alla funzione Iva. In generale, i parametri per i quali ci serve un valore di ritorno sono detti parametri di output, mentre gli altri sono detti parametri di input o di input/output. ---------------------------------------------------------------------------------------------------------------- I parametri opzionali Nel caso in cui volessimo utilizzare alcuni parametri senza obbligare chi utilizza le nostre procedure ad utilizzarli, potremmo dichiararli come opzionali. Per dichiarare un parametro opzionale è sufficiente indicare prima la parola chiave Optional con il seguente accorgimento: se viene utilizzata, anche tutti gli argomenti successivi devono essere facoltativi e dichiarati con la parola chiave Optional. E’ possibile associare un valore di default al parametro mancante oppure controllarne l’esistenza con la funzione di VB IsMissing (la quale però funziona solo con tipi di dati variant). Torniamo sempre al nostro solito esempio, potremmo permettere al nostro utilizzatore di specificare l’aliquota IVA solo nel caso in cui sia diversa da 4. Function IVA(Importo As Long, Optional Aliquota As Single = 4) As Long IVA = Importo * Aliquota / 1000 End Function Dunque per calcolare l’iva al 4% sarà sufficiente specificare l’importo: MsgBox IVA(100000) ----------------------------------------------------------------------------------------------------------------- La stessa funzione la si può riprodurre utilizzando la funzione IsMissing, ovvero verificando se il valore del parametro è stato specificato e, in caso contrario, assegnarvi un valore di default. Function IVA(Importo As Long, Optional Aliquota) As Long If IsMissing(Aliquota) Then Aliquota = 4 End If IVA = Importo * Aliquota / 1000 End Function Validità delle funzioni L’ambito di validità delle procedure e funzioni e simile a quello visto per le variabili: possono essere pubbliche o private (Private o Public) e possono appartenere ad una FORM oppure ad un modulo .BAS. Nel primo caso, anche se pubbliche, per poterle richiamare occorre specificare prima il nome della FORM di appartenenza. Le costanti Anche il concetto di costante è molto importante per un programmatore, in quanto è presente in tutti i linguaggi di programmazione. ---------------------------------------------------------------------------------------------------------------- a costante non è altro che una sorta di “variabile costante” ovvero un’area di memoria alla quale si assegna un nome ed un valore che non potrà cambiare durante l’esecuzione del programma. Il caso classico è quello del valore del pi-greco per calcolare circonferenza ed area di un cerchio. Può essere comodo, all’inizio del programma, dichiarare una costante denominata PIGRECO (solitamente il nome delle costanti è maiuscolo per convenzione) avente il valore 3,1415..… Non sarà indispensabile ricordarsi ogni volta il valore completo ma sarà sufficiente utilizzare la costante PIGRECO. La dichiarazione è simile a quella delle variabili utilizzando la parola chiave CONST, naturalmente con PRIVATE per le costanti riservate ad un modulo e PUBLIC per quelle pubbliche con la particolarità che le costanti dichiarate all’interno di un form non possono essere pubbliche Private Const PIGRECO = 3.141592 E la prossima lezione? Inizieremo a studiare le principali funzioni fornite da Visual Basic. Non mancate!! ----------------------------------------------------------------------------------------------------------------- Abbiamo imparato a creare ed utilizzare le procedure e le funzioni. In questa e nelle prossime lezione impareremo a cosa servono le principali funzioni messe a disposizione da Visual Basic. Le principali funzioni di Visual Basic Le funzioni di conversione di tipo Questa categoria di funzioni serve per convertire variabili od espressioni da un tipo di dato ad un altro. Se non specificato diversamente esse richiedono un parametro di input e restituiscono un valore del tipo di dato specificato. CBool: permette di modificare qualsiasi espressione valida (numerica o stringa) in TRUE o FALSE. Esempio: Dim Numero1 as integer Dim Numero2 as integer Dim Confronto as boolean Numero1 = 3 Numero2 = 2 Confronto = CBool(Numero1 = Numero2) ' Confronta ora contiene FALSE Numero2 = 3 Confronto = CBool(Numero1 = Numero2) ' Confronta ora contiene TRUE --------------------------------------------------------------------------------------------------------------- CDate: questa funzione, data una qualsiasi espressione valida che rappresenta una data, restituisce un valore di tipo DATE. Esempio: Dim DataInCaratteri as String Dim DataData as Date DataInCaratteri = "13 marzo 1987" ' Variabile stringa contenete un espressione che rappresenta una data DataData = CDate(DataInCaratteri) ' Converte nel tipo di dati Date. CInt: serve per convertire un espressione valida in un numero intero (ovvero da - 32.768 a 32.767). Se l’espressione passata come parametro rappresenta un numero con virgola, il risultato sarà un intero approssimato per eccesso o per difetto. Esempio: Dim NumeroConVirg as double Dim NumeroIntero as integer Dim NumeroStringa as string NumeroConVirg = 337.78 NumeroIntero = CInt(NumeroConVirg) ' ora NumeroIntero contiene 338 NumeroStringa = "52" NumeroIntero = CInt(NumeroStringa) ' ora NumeroIntero contiene 52 Esistono funzioni analoghe anche per convertire un’espressione neglli altri tipi di dati numerici, Byte, Long, Single, Double ovvero CByte, CLng, CSng, CDbl. ----------------------------------------------------------------------------------------------------------------- CStr: converte in stringa l’espressione che viene passata come parametro. Esempio: Dim VerooFalso As Boolean Dim Stringa As String Dim NumConVirgola As Double VerooFalso = True Stringa = CStr(VerooFalso) ‘Restituisce VERO o TRUE se il sistema operativo è in inglese NumConVirgola = 3.4 Stringa = CStr(NumConVirgola) ‘Restituisce 3,4 o 3.4 se il sistema operativo ha le impostazioni inglesi o americane Str: è una funzione analoga alla CStr, con la differenza che converte solo espressioni numeriche in stringa e non accetta altre espressioni (es. boolean o date). MyString = Str(459) ' Restituisce " 459" MyString = Str(-459.65) ' Restituisce "-459,65". MyString = Str(459.001) ' Restituisce " 459,001". ----------------------------------------------------------------------------------------------------------------- Val: è una funzione di conversione in numero più generalizzata delle precedenti: ovvero accetta un stringa e la restituisce sotto forma di valore numerico di tipo appropriato cercando di interpretare anche frasi più complesse. Esempio: Numero = Val("13") Numero = Val("13 cose") ‘ in entrambi i casi Numero conterrà 13 Numero = Val("cose") ‘ in questo caso conterrà 0 in quanto non interpretabile Asc: converte un carattere nel corrispondente codice della tabella ASCII (valore intero tra 0 e 255). Codice = Asc("A") ' Restituisce 65 Codice = Asc("a") ' Restituisce 97. ---------------------------------------------------------------------------------------------------------------- Chr: E’ la funzione inversa ad Asc, ovvero dato un codice della tabella ASCII ne restituisce il carattere corrispondente: Carattere = Chr(65) ' Restituisce A Carattere = Chr(97) ' Restituisce a. I numeri da 0 a 31 corrispondono ai codici ASCII standard non stampabili. La funzione Chr(13), ad esempio, restituisce il carattere di INVIO a capo. Msgbox “Ciao “ + chr(13) + “ a tutti” visualizzerà Ciao a tutti Ma le sorprese non sono ancora finite, VB ci ha regalato molte altre funzioni, non mi resta che invitarvi a partecipare alla prossima lezione. Non mancate! ----------------------------------------------------------------------------------------------------------------- Abbiamo imparato a creare ed utilizzare le procedure e le funzioni. In questa e nelle prossime lezione impareremo a cosa servono le principali funzioni messe a disposizione da Visual Basic. Le principali funzioni di VBA Format: è una funzione molto utile, in quanto serve per “formattare” un’espressione in un formato desiderato, ovvero, per stampare i numeri con i punti separatori delle migliaia oppure per visualizzare una data con l’anno di 4 cifre o anche per visualizzare una frase tutta in maiuscolo. Sintassi: Format(espressione[, formato]) Il tipo di formato dipendende naturalmente dal contenuto dell’espressione, ecco alcuni esempi: MsgBox Format(Date, "Long Date") visualizza la data corrente nel formato esteso MsgBox Format(Date, "dd/mm/yyyy") visualizza la data corrente in formato giorno/mese/annoin4cifre ---------------------------------------------------------------------------------------------------------------- MsgBox Format(5459.4, "##,##0.00") Restituisce 5.459,40 MsgBox Format(1334.9, "###0.00") Restituisce 1334,90. MsgBox Format("CIAO", "<") Restituisce "ciao". MsgBox Format("ciao", ">") Restituisce "CIAO". Funzioni di manipolazione delle stringhe Instr: Restituisce un valore numerico che specifica la posizione della prima occorrenza di una stringa all'interno di un'altra. Sintassi: InStr([inizio, ]stringa1, stringa2[, confronto]) Esempio: InStr(1,"ciao a tutti voi", "tutti") restituisce il valore 8. Il tipo di confronto, se non specificato è quello specificato nell’istruzione Option Compare (*) altrimenti può essere di tipo binario (VbBinaryCompare) e testo (VbTextCompare). ----------------------------------------------------------------------------------------------------------------- (*) L’istruzione Option Compare può essere utilizzata a livello di modulo per dichiarare la modalità di confronto predefinita da utilizzare per confrontare i dati di una stringa (se non specificato diversamente si usa il confronto binario). Sintassi: Option Compare {Binary | Text | Database} Mid: Restituisce un certo numero di caratteri estraendolo da una posizione specificata di una stringa di partenza. I parametnri da specificare sono dunque la stringa di partenza, il punto da cui inziare l’estrazione ed il numero di caratteri da estrarre (se non è specificato si intende fino alla fine). Sintassi: Mid(string, start[, length]) Esempio: Mid(“ciao a tutti voi", 8, 5) restituisce il “tutti”. ---------------------------------------------------------------------------------------------------------------- Ucase e LCase: Restituiscono un la stringa passata come parametro, convertita in maiuscole oppure in minuscole. Sintassi: UCase(stringa), LCase(stringa) Esempio: UCase(“ciao a tutti voi”) restituisce il “CIAO A TUTTI VOI”. LCase(“CIAO A TUTTI VOI”) restituisce il “ciao a tutti voi”. Left e Right: Restituiscono un numero specificato di caratteri di una stringa a partire da sinistra o da destra. Sintassi Left(string, length), Right(string, length) Esempio: Left(“ciao a tutti voi”,4) restituisce “ciao” Right(“ciao a tutti voi”,3) restituisce “voi” ----------------------------------------------------------------------------------------------------------------- Trim, Ltrim e Rtrim Restituiscono la stringa di partenza senza spazi iniziali (LTrim), spazi finali (RTrim) o senza spazi iniziali e finali (Trim). Sintassi LTrim(stringa) RTrim(stringa) Trim(stringa) Esempio: Trim(“ ciao ”) restituisce “ciao” LTrim(“ ciao ”) restituisce “ciao ” RTrim(“ ciao ”) restituisce “ ciao” Cosa ne dite? Queste erano le funzioni principali per lavorare sulle stringhe, ma ne esistono altre! La prossima lezione finalmente termineremo la carrellata sulle funzioni fornite da VB imparando quelle relative alle date ed ai numeri. ---------------------------------------------------------------------------------------------------------------- In questa lezione finalmente termineremo lo studio delle funzioni fornite da Visual Basic imparando quelle relative alle date ed ai numeri. Funzioni di manipolazione delle date: Date: E’ una funzione che restituisce la data di sistema corrente. Esempio: msgbox Format(Date,”dd-mm-yyyy”) Supponendo che oggi sia il 2/6/2001 questo esempio restituirà 02-06-2001 Year: Restituisce un valore numerico intero corrispondente all’anno della data passata come parametro Month: Restituisce un valore numerico intero corrispondente al mese della data passata come parametro ---------------------------------------------------------------------------------------------------------------- Day: Restituisce un valore numerico intero corrispondente al giorno della data passata come parametro Esempio: msgbox Day(Date) msgbox Month(Date) msgbox Year(Date) Supponendo che oggi sia il 2/6/2001 restituisce 2, 6, poi 2001 IsDate: Restituisce un valore Booleano (True o False) che indica se è possibile o meno convertire l’espressione passata come parametro in data. Successivamente, se l’esito di questo controllo è positivo, si potrà convertire utilizzando l’apposita funzione di conversione CDate. Esempio: If IsDate("29/31/2001") Then MsgBox "Data Corretta" Else MsgBox "La data passata non è valida!" End If Questo esempio dirà che “la data passata non è valida” ----------------------------------------------------------------------------------------------------------------- Funzioni numeriche: Round: Restituisce un numero arrotondato in base al numero di cifre decimali specificato. Sintassi: Round(espressione[, numcifredecimali]) Esempio: MsgBox Round(8.98737, 1) restituirà 9 MsgBox Round(8.94737, 2) restituirà 8,95 MsgBox Round(8.94737, 3) restituirà 8,947 MsgBox Round(8.94737, 4) restituirà 8,9474 Sqr: Restituisce un valore Double che specifica la radice quadrata di un numero. Abs: Restituisce un valore che specifica il valore assoluto di un numero. Il valore restituito sarà dello stesso tipo di quello passato alla funzione. Ad esempio ABS(-2) e ABS(2) restituiscono entrambi 2. Cos e Sin: Restituiscono un valore Double che specifica il coseno o il seno di un angolo. Queste sono le funzioni principali di VBA, ma ne esistono altre che impareremo di volta in volta all’occorrenza! Ed ora che finalmente siamo in possesso di sufficienti strumenti, potremo approfondire l’utilizzo dei controlli di Visual Basic facendo molti esempi interessanti. Alla prossima! ---------------------------------------------------------------------------------------------------------------- Prima di procedere all’apprendimento dei principali controlli di Visual Basic, è utile conoscere a fondo le potenzialità del suo ambiente di sviluppo ed in particolare del DEBUG. Il debug Per poter controllare la correttezza di un programma è utile eseguire passo passo le istruzioni che vengono eseguite, controllarne l’ordine ed il valore assunto dalle variabili locali e globali: questo strumento è denominato DEBUG. Le potenzialità del DEBUG differiscono a seconda del linguaggio di programmazione utilizzato, ma quello di Visual Basic è sicuramente uno dei più comodi e potenti. Avevamo già detto nella seconda lezione che nell'ambiente di lavoro di VB si opera in 3 modi: Design (progettazione): quando si sta costruendo l’applicazione Run (esecuzione): quando si sta eseguendo l’applicazione Break: in fase di debug (controllo passo passo) dell’applicazione Quest’ultima modalità è quella che ci permette di fare DEBUG! ---------------------------------------------------------------------------------------------------------------- Il DEBUG di Visual Basic permette di: - impostare punti di interruzione, ovvero specificare delle istruzioni sulle quali vogliamo che l’interprete si fermi (ovvero operi in fase di INTERRUZIONE/BREAK) per permetterci di fare le nostre verifiche - utilizzare espressioni di controllo: ovvero, in fase di BREAK, avere la possibilità di visionare il risultato di un’espressione - analizzare il codice eseguendo una istruzione o routine alla volta - visualizzare i valori di variabili e proprietà - apportare modifiche al codice e continuare quindi l'esecuzione - saltare l’esecuzione di una istruzione passando ad un’altra seguente o precedente Gli strumenti di debug Punto di interruzione: come avevamo già detto è possibile impostare la riga nella finestra del codice in cui l'esecuzione dell'applicazione deve essere interrotta. Per specificare tale o tali punti è sufficiente, in fase di DESIGN, posizionarsi sulla riga voluta (nella finestra del codice) e digitare F9 oppure fare click a sinistra (a inizio colonna): la riga corrispondente viene evidenziata in marrone. ----------------------------------------------------------------------------------------------------------------- Una volta avviato il programma (dal menù ESEGUI – AVVIA o digitando F5), non appena l’esecuzione arriva sul punto di interruzione, si passa dalla modalità RUN a quella di BREAK. La finestra attiva diventa quella dell’editor del codice e in corrispondenza della linea di interruzione compare una freccia gialla. Tale freccia indica l’istruzione che sta per essere eseguita ed indica anche che ci troviamo in modalità BREAK. Se non avete impostato punti di interruzione, è possibile comunque passare in tale modalità digitando CTRL + PAUSA. Se si “tira” la freccia gialla su un’altra riga, vengono saltate le istruzioni prima e l’esecuzione viene spostata su questa nuova riga. Da notare anche una funzionalità molto carina: passando su una variabile o una proprietà con il mouse viene visualizzato il suo valore !! Esegui istruzione (menù DEBUG oppure tasto F8): esegue la riga successiva a quella evidenziata in giallo ----------------------------------------------------------------------------------------------------------------- Esegui istruzione/routine (menù DEBUG oppure tasti SHIFT+F8): esegue la riga successiva a quella evidenziata in giallo senza entrare nelle sottofunzioni Esempio: call MyProc() Msgbox “Ciao” … dove Sub MyProc() Msgbox “MyProc” End Sub Se sono sulla prima riga e digito SHIFT + F8, passero’ subito su Msgbox “Ciao” (ovvero, il messaggio “MyProc” verrà visualizzato, ma non vedro’ il relativo punto di interruzione). Digitando F8 mi addentrero’ invece nella Sub MyProc e quindi la freccia gialla si fermerà prima in corrispondenza di Msgbx “MyProc” Esci da istruzione/routine (menù DEBUG oppure tasto SHFT + CTRL + F8) Esegue le rimanenti istruzioni della routine corrente fino alla riga successiva della routine chiamante. ----------------------------------------------------------------------------------------------------------------- Finestra Variabili locali (menù Visualizza) E’ una finestra molto utile che richiama dal menù Visualizza e permette di controllare il valore corrente delle variabili locali. Finestra Immediata Consente di verificare valori del codice o eseguire delle istruzione mentre è attivata la modalità interruzione (la vedremo in modo approfondito nelle prossime lezioni) Finestra Espressioni di controllo Permette di visualizzare i valori di espressioni opportunamente indicate (ad esempio risultati di assegnazioni, somme ecc). Controllo immediato Visualizza il valore corrente di un'espressione mentre è attivata la modalità interruzione. Stack di chiamate In modalità interruzione, visualizza una finestra di dialogo in cui sono elencate tutte le routine che sono state chiamate, ma non ancora completate. Ovvero da chi è stata chiamata la routine su cui si trova nel momento dell’interruzione. ----------------------------------------------------------------------------------------------------------------- I principali tasti funzione del DEBUG di Visual Basic - F5 permette di avviare il programma: se incontra un punto di interruzione si arresta in quel punto e passa in modalità BREAK - F8 per eseguire le istruzioni passo passo - SHIFT + F8 per eseguire le istruzioni passo passo senza addentrarsi nei sottoprogrammi - CTRL + L per visualizzare le routine che sono state chiamate, ma non ancora completate. - CTRL + G per aprire la finestra IMMEDIATA che consente di eseguire i valori del codice mentre è attivata la modalità interruzione - CTRL + PAUSA permette di passare alla modalità di BREAK Bene, questo è un primo assaggio dello strumento di DEBUG. Nelle prossime lezioni proveremo a produrre degli errori, a farne il DEBUG ed anche a gestirli! Alla prossima!